// pages/pay/recharge/index.js
const auth = require('../../../utils/auth.js');
const apiService = require('../../../utils/api.js');
const setting = require('../../../setting/setting.js');
const app = getApp();

Page({

	/**
	 * 页面的初始数据
	 */
	data: {
		statusBarHeight: 0, // 系统状态栏高度
		balance: 0.00, // 当前可用余额
		shopName: '加载中...', // 店铺名称
		currentStore: {
			id: null,
			name: '加载中...'
		},
		selectedPackageIndex: 0, // 默认选中第一个充值套餐
		isAgreed: false, // 协议是否已勾选
		rechargePackages: []
	},

	/**
	 * 生命周期函数--监听页面加载
	 */
	onLoad(options) {
		// 初始化 DataManager
		this.dataManager = app.dataManager;
		// 获取系统信息
		this.getSystemInfo();
		// 加载店铺信息
		this.loadStoreInfo();
		// 加载用户余额
		this.loadUserBalance();
		// 加载充值套餐包
		this.loadRechargePackages();
	},

	/**
	 * 获取系统信息
	 */
	getSystemInfo() {
		wx.getSystemInfo({
			success: (res) => {
				this.setData({
					statusBarHeight: res.statusBarHeight || 44
				})
			},
			fail: (error) => {
				console.error('获取系统信息失败:', error)
				this.setData({
					statusBarHeight: 44
				})
			}
		})
	},

	/**
	 * 加载店铺信息
	 */
	async loadStoreInfo() {
		try {
			const storeManager = getApp().getStoreManager();
			const storeList = await storeManager.getStoreList();
			const result = { success: true, data: storeList };
			if (result.success && result.data && result.data.length > 0) {
				// 优先显示距离用户最近的店铺，若无法获取用户地址则显示storeId为'store_001'的店铺
				let selectedStore = result.data.find(store => store.storeId === 'store_001') || result.data[0];
				
				// 尝试获取用户位置，选择最近的店铺
				try {
					const location = await this.getUserLocation();
					if (location) {
						// 计算距离并选择最近的店铺
						let minDistance = Infinity;
						for (const store of result.data) {
							if (store.latitude && store.longitude) {
								const distance = this.calculateDistance(
									location.latitude, location.longitude,
									store.latitude, store.longitude
								);
								if (distance < minDistance) {
									minDistance = distance;
									selectedStore = store;
								}
							}
						}
					}
				} catch (locationError) {
					console.log('获取用户位置失败，使用默认店铺:', locationError);
				}
				
				this.setData({
					currentStore: selectedStore,
					shopName: selectedStore.name
				});
			} else {
				console.error('获取店铺列表失败:', result.message);
				// 降级处理：使用默认店铺信息
				this.setData({
					currentStore: {
						id: 1,
						name: '超级泡泡'
					},
					shopName: '超级泡泡'
				});
			}
		} catch (error) {
			console.error('加载店铺信息失败:', error);
			// 降级处理：使用默认店铺信息
			this.setData({
				currentStore: {
					id: 1,
					name: '超级泡泡'
				},
				shopName: '超级泡泡'
			});
		}
	},

	/**
	 * 获取用户位置
	 */
	async getUserLocation() {
		return new Promise((resolve, reject) => {
			wx.getLocation({
				type: 'gcj02',
				success: (res) => {
					resolve({
						latitude: res.latitude,
						longitude: res.longitude
					});
				},
				fail: (error) => {
					console.log('获取位置失败:', error);
					reject(error);
				}
			});
		});
	},

	/**
	 * 计算两点间距离（单位：公里）
	 */
	calculateDistance(lat1, lng1, lat2, lng2) {
		const R = 6371; // 地球半径（公里）
		const dLat = (lat2 - lat1) * Math.PI / 180;
		const dLng = (lng2 - lng1) * Math.PI / 180;
		const a = Math.sin(dLat / 2) * Math.sin(dLat / 2) +
				Math.cos(lat1 * Math.PI / 180) * Math.cos(lat2 * Math.PI / 180) *
				Math.sin(dLng / 2) * Math.sin(dLng / 2);
		const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
		return R * c;
	},

	/**
	 * 加载用户余额
	 */
	async loadUserBalance(forceRefresh = false) {
		try {
			// 检查登录状态
			const isLoggedIn = await auth.checkLoginStatus();
			if (!isLoggedIn) {
				console.log('用户未登录，跳转到登录页面');
				auth.requireLogin();
				return;
			}

			// 通过 DataManager 获取用户余额
			const balance = await this.dataManager.getUserBalance(forceRefresh);
			if (balance !== null && balance !== undefined) {
				this.setData({
					balance: (balance / 100).toFixed(2) // 将分转换为元，保留两位小数
				});
				console.log('用户余额加载成功:', this.data.balance);
			} else {
				console.warn('获取用户余额失败');
				this.setData({
					balance: '0.00'
				});
			}
		} catch (error) {
			console.error('加载用户余额失败:', error);
			this.setData({
				balance: '0.00'
			});
			// 如果是认证相关错误，跳转到登录页面
			if (error.message && error.message.includes('登录')) {
				auth.requireLogin();
			}
		}
	},

	/**
	 * 加载充值套餐包列表
	 */
	async loadRechargePackages() {
		try {
			const result = await apiService.getRechargePackages();
			if (result.success) {
				this.setData({
					rechargePackages: result.data || []
				});
				console.log('充值套餐包加载成功:', result.data);
			} else {
				console.error('加载充值套餐包失败:', result.message);
				wx.showToast({
					title: '加载套餐失败',
					icon: 'none'
				});
			}
		} catch (error) {
			console.error('加载充值套餐包异常:', error);
			wx.showToast({
				title: '网络异常',
				icon: 'none'
			});
		}
	},

	/**
	 * 返回上一页
	 */
	onBack() {
		wx.navigateBack({
			delta: 1,
			success: () => {
				console.log('返回上一页成功')
			},
			fail: (error) => {
				console.error('返回上一页失败:', error)
				// 降级处理：跳转到首页
				wx.switchTab({
					url: '/pages/home/index/index'
				})
			}
		})
	},

	/**
	 * 选择充值套餐
	 */
	selectPackage(e) {
		const index = e.currentTarget.dataset.index
		this.setData({
			selectedPackageIndex: index
		})
	},

	/**
	 * 切换协议勾选状态
	 */
	toggleAgreement() {
		this.setData({
			isAgreed: !this.data.isAgreed
		})
	},

	/**
	 * 查看使用明细
	 */
	viewUsageDetails() {
		wx.navigateTo({
			url: '/pages/pay/recharge-records/index'
		});
	},

	/**
	 * 查看充值说明
	 */
	showRechargeInfo() {
		wx.showModal({
			title: '充值说明',
			content: '1. 充值余额可用于门店美容、寄养等服务\n2. 充值余额永久有效，不支持退款\n3. 充值成功后会立即到账\n4. 如有疑问请联系客服',
			showCancel: false,
			confirmText: '知道了'
		})
	},

	/**
	 * 显示充值管理条款
	 */
	showRechargeAgreement(e) {
		wx.navigateTo({
			url: '/pages/home-sub/agreement/index?type=privacy',
			success: () => {
				console.log('跳转到隐私政策页面成功');
			},
			fail: (error) => {
				console.error('跳转到隐私政策页面失败:', error);
				wx.showToast({
					title: '跳转失败，请重试',
					icon: 'none'
				});
			}
		});
	},

	/**
	 * 立即充值
	 */
	async handleRecharge() {
		// 检查登录状态
		try {
			const isLoggedIn = await auth.checkLoginStatus();
			if (!isLoggedIn) {
				wx.showModal({
					title: '提示',
					content: '请先登录后再进行充值',
					confirmText: '去登录',
					cancelText: '取消',
					success: (res) => {
						if (res.confirm) {
							auth.requireLogin();
						}
					}
				});
				return;
			}
		} catch (error) {
			console.error('检查登录状态失败:', error);
			wx.showModal({
				title: '提示',
				content: '请先登录后再进行充值',
				confirmText: '去登录',
				cancelText: '取消',
				success: (res) => {
					if (res.confirm) {
						auth.requireLogin();
					}
				}
			});
			return;
		}

		if (!this.data.isAgreed) {
			wx.showToast({
				title: '请先同意充值管理条款',
				icon: 'none',
				duration: 2000
			})
			return
		}

		const selectedPackage = this.data.rechargePackages[this.data.selectedPackageIndex]
		const totalAmount = selectedPackage.amount + selectedPackage.bonus

		wx.showModal({
			title: '确认充值',
			content: `充值 ¥${selectedPackage.amount}，赠送 ¥${selectedPackage.bonus}，实际到账 ¥${totalAmount}`,
			success: (res) => {
				if (res.confirm) {
					this.processPayment(selectedPackage)
				}
			}
		})
	},

	/**
	 * 处理支付
	 */
	async processPayment(packageInfo) {
		try {
			wx.showLoading({
				title: '创建支付订单...',
				mask: true
			});

			// 创建充值订单记录（后端已包含支付参数生成）
			const orderResult = await apiService.createRechargeOrder(
				packageInfo.amount * 100, // 转换为分
				packageInfo.bonus * 100,  // 转换为分
				packageInfo.id.toString()
			);

			console.log('创建充值订单结果:', orderResult);

			if (!orderResult.success) {
				throw new Error(orderResult.message || '创建订单失败');
			}

			// 检查是否有支付参数
			if (!orderResult.data || !orderResult.data.paymentParams) {
				throw new Error('获取支付参数失败');
			}

			wx.hideLoading();

			// 直接使用后端返回的支付参数进行支付
			await this.requestPayment(orderResult.data.paymentParams, orderResult.data.rechargeOrderId);

		} catch (error) {
			wx.hideLoading();
			console.error('支付处理失败:', error);
			wx.showToast({
				title: error.message || '支付失败',
				icon: 'none',
				duration: 2000
			});
		}
	},

	/**
	 * 发起微信支付
	 */
	async requestPayment(paymentParams, rechargeOrderId) {
		// 在开始前统一归一化，兼容 _isTestMode → testMode
		paymentParams = apiService.normalizeWxPaymentParams(paymentParams);
		// 检查是否为测试模式
		if (paymentParams.testMode) {
			console.log('测试模式：模拟支付成功');
			wx.showToast({
				title: '测试模式：支付成功',
				icon: 'success',
				duration: 2000
			});
			// 模拟支付成功结果
			const mockResult = {
				transactionId: `test_${Date.now()}`,
				payTime: Math.floor(Date.now() / 1000),
				status: 'success'
			};
			// TEST_MODE 下主动调用云端充值回调，确保余额入账（仅云函数模式）
			try {
				if (!setting.USE_SELF_BACKEND_PAYMENT) {
					const callbackResult = await apiService.handleRechargeCallback(rechargeOrderId, mockResult);
					if (callbackResult && callbackResult.success) {
						await this.handlePaymentSuccess(rechargeOrderId, mockResult);
						return Promise.resolve(mockResult);
					} else {
						wx.showToast({ title: (callbackResult && callbackResult.message) || '充值确认失败', icon: 'none' });
						return Promise.reject(new Error((callbackResult && callbackResult.message) || '充值确认失败'));
					}
				} else {
					// 自建后端模式：不主动调用云端充值回调
					await this.handlePaymentSuccess(rechargeOrderId, mockResult);
					return Promise.resolve(mockResult);
				}
			} catch (error) {
				console.error('测试模式回调处理失败:', error);
				return Promise.reject(error);
			}
		}
	
		// 归一化支付参数，提升容错能力
		if (paymentParams) {
		// 某些服务端可能返回数值型 timeStamp 或使用 timestamp 命名
		if (typeof paymentParams.timeStamp === 'number') {
		paymentParams.timeStamp = String(paymentParams.timeStamp);
		}
		if (!paymentParams.timeStamp && typeof paymentParams.timestamp !== 'undefined') {
		paymentParams.timeStamp = String(paymentParams.timestamp);
		}
		// 兼容 nonce 字段别名
		if (!paymentParams.nonceStr) {
		if (paymentParams.nonce) paymentParams.nonceStr = paymentParams.nonce;
		if (paymentParams.noncestr) paymentParams.nonceStr = paymentParams.noncestr;
		}
		// 兼容签名字段别名
		if (!paymentParams.paySign && paymentParams.sign) {
		paymentParams.paySign = paymentParams.sign;
		}
		// 若缺失 signType，但已生成 paySign，默认使用 RSA
		if (!paymentParams.signType && paymentParams.paySign) {
		paymentParams.signType = 'RSA';
		}
		// 兼容 package 字段别名
		if (!paymentParams.package && paymentParams.packageValue) {
		paymentParams.package = paymentParams.packageValue;
		}
		// 若缺失 package，但存在预支付单号，自动构造
		if (!paymentParams.package) {
		if (paymentParams.prepay_id) {
		paymentParams.package = `prepay_id=${paymentParams.prepay_id}`;
		} else if (paymentParams.prepayId) {
		paymentParams.package = `prepay_id=${paymentParams.prepayId}`;
		}
		}
		// 去除字符串字段的首尾空格
		['timeStamp','nonceStr','package','signType','paySign'].forEach(k => {
			if (typeof paymentParams[k] === 'string') {
				paymentParams[k] = paymentParams[k].trim();
			}
		});
		// 统一归一化，提高容错
		paymentParams = apiService.normalizeWxPaymentParams(paymentParams);
		
		// 参数校验（JSAPI 必须字段）
		const requiredKeys = ['timeStamp', 'nonceStr', 'package', 'signType', 'paySign'];
		const invalid = !paymentParams || requiredKeys.some(k => typeof paymentParams[k] !== 'string' || !paymentParams[k]);
		if (invalid) {
			console.error('微信支付参数异常:', paymentParams);
			wx.showToast({
				title: '支付参数异常',
				icon: 'none'
			});
			await this.handlePaymentFailure(rechargeOrderId, { errMsg: 'invalid payment params' });
			return Promise.reject(new Error('支付参数异常'));
		}
	
		// 正常微信支付流程
		return new Promise((resolve, reject) => {
			wx.requestPayment({
				timeStamp: paymentParams.timeStamp,
				nonceStr: paymentParams.nonceStr,
				package: paymentParams.package,
				signType: paymentParams.signType,
				paySign: paymentParams.paySign,
				success: async (res) => {
					console.log('微信支付成功:', res);
					await this.handlePaymentSuccess(rechargeOrderId, res);
					resolve(res);
				},
				fail: async (err) => {
					console.log('微信支付失败:', err);
					if (err.errMsg.includes('cancel')) {
						wx.showToast({ title: '支付已取消', icon: 'none' });
					} else {
						await this.handlePaymentFailure(rechargeOrderId, err);
					}
					reject(err);
				}
			});
		});
		}
	},

	/**
	 * 处理支付成功
	 */
	async handlePaymentSuccess(rechargeOrderId, paymentResult) {
		try {
			wx.showLoading({
				title: '处理中...',
				mask: true
			});

			// V3版本：不在客户端主动调用充值回调，等待微信服务端通知（notify_url）完成入账
			wx.hideLoading();

		wx.showToast({ title: '充值成功', icon: 'success', duration: 2000 });

		// 清除用户相关缓存，确保个人中心页面能获取最新数据
		const app = getApp();
		const dataManager = app.getDataManager();
		dataManager.invalidateUserCache();
		console.log('[充值成功] 已清除用户缓存');

		// 重新加载用户余额（入账依赖服务端回调，稍作等待后刷新）
		await this.loadUserBalance(true); // 强制刷新缓存

		// 通知个人中心页面刷新数据
		const pages = getCurrentPages();
		const profilePage = pages.find(page => page.route === 'pages/main/user-profile/index');
		if (profilePage && typeof profilePage.refreshUserData === 'function') {
			console.log('[充值成功] 通知个人中心页面刷新数据');
			profilePage.refreshUserData();
		}

		// 重置选择状态
		this.setData({ selectedPackageIndex: 0, isAgreed: false });
		} catch (error) {
			wx.hideLoading();
			console.error('支付成功处理失败:', error);
			wx.showToast({ title: error.message || '充值处理失败', icon: 'none', duration: 2000 });
		}
	},

	/**
	 * 处理支付失败
	 */
	async handlePaymentFailure(rechargeOrderId, paymentError) {
		try {
			// 客户端不主动上报失败回调，保持与微信支付 v3 回调一致由服务端处理
			wx.showToast({ title: '支付失败', icon: 'none', duration: 2000 });
		} catch (error) {
			console.error('支付失败处理错误:', error);
		}
	},

	/**
	 * 生命周期函数--监听页面初次渲染完成
	 */
	onReady() {

	},

	/**
	 * 生命周期函数--监听页面显示
	 */
	onShow() {
		// 每次显示页面时重新加载用户余额
		this.loadUserBalance();
	},

	/**
	 * 生命周期函数--监听页面隐藏
	 */
	onHide() {

	},

	/**
	 * 生命周期函数--监听页面卸载
	 */
	onUnload() {

	},

	/**
	 * 页面相关事件处理函数--监听用户下拉动作
	 */
	onPullDownRefresh() {

	},

	/**
	 * 页面上拉触底事件的处理函数
	 */
	onReachBottom() {

	},

	/**
	 * 页面滚动监听
	 */
	onPageScroll(e) {
		const scrollY = e.scrollTop;
		
		// 计算导航栏背景透明度，滚动距离0-100px内从透明变为不透明
		const maxScrollDistance = 100; // 滚动距离阈值（像素）
		const opacity = Math.min(scrollY / maxScrollDistance, 1);
		
		// 计算文字颜色，透明度达到0.5时开始变黑
		const textColor = opacity >= 0.5 ? '#120E0C' : '#333333';
		
		// 只有在透明度或文字颜色发生变化时才更新
		if (this.data.navbarOpacity !== opacity || this.data.navbarTextColor !== textColor) {
			this.setData({
				scrollY: scrollY,
				navbarOpacity: opacity,
				navbarTextColor: textColor
			});
		}
	},

	/**
	 * 用户点击右上角分享
	 */
	onShareAppMessage() {

	}
})